// pages/chat/chat.js
const api = require('../../utils/api.js');

Page({
  /**
   * 页面的初始数据
   */
  data: {
    // 聊天消息列表
    messageList: [],
    // 输入框内容
    inputValue: '',
    // 是否正在发送消息
    isSending: false,
    // 是否正在等待AI回复
    isWaitingReply: false,
    // 当前会话ID
    sessionId: '',
    // 当前AI模型
    currentModel: 'deepseek-chat',
    // 功能类型（从专业助理进入时会有）
    functionType: '',
    // 页面标题
    pageTitle: 'AI对话',
    // 滚动到底部的标识
    scrollToBottom: false,
    
    // 图标URLs
    aiPortraitUrl: '',
    sendIconUrl: ''
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    console.log('聊天页面加载:', options);
    
    // 初始化图标URLs
    const { getIconUrl } = require('../../utils/imageUtils.js');
    this.setData({
      aiPortraitUrl: getIconUrl('AIPortrait.png'),
      sendIconUrl: getIconUrl('send.png')
    });
    
    const { query, model, functionType, id, continueChat } = options;
    
    // 设置页面标题
    let title = 'AI对话';
    if (functionType) {
      title = decodeURIComponent(functionType);
    }
    
    wx.setNavigationBarTitle({
      title: title
    });
    
    let sessionId;
    let shouldLoadHistory = false;
    
    // 如果是打开已有会话
    if (id) {
      sessionId = id;
      shouldLoadHistory = true;
    } else if (continueChat === 'true') {
      // 如果要继续最近的对话
      const recentChat = this.getRecentChatForModel(model || 'deepseek-chat');
      if (recentChat) {
        sessionId = recentChat.sessionId;
        shouldLoadHistory = true;
      } else {
        sessionId = this.generateSessionId();
      }
    } else {
      // 生成新的会话ID
      sessionId = this.generateSessionId();
    }
    
    this.setData({
      sessionId,
      currentModel: model || 'deepseek-chat',
      functionType: functionType || '',
      pageTitle: title
    });
    
    // 加载聊天历史
    if (shouldLoadHistory) {
      this.loadChatHistory(sessionId);
    }
    
    // 如果有查询内容，直接发送
    if (query) {
      this.setData({
        inputValue: decodeURIComponent(query)
      });
      this.sendMessage();
    }
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 滚动到底部
    this.scrollToBottom();
  },

  /**
   * 生成会话ID
   */
  generateSessionId() {
    return 'session_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
  },

  /**
   * 获取指定模型的最近聊天记录
   */
  getRecentChatForModel(modelId) {
    const chatHistory = wx.getStorageSync('chatHistory') || [];
    
    // 查找指定模型的最近对话
    const recentChat = chatHistory.find(chat => 
      chat.model === modelId && chat.messages && chat.messages.length > 0
    );
    
    return recentChat;
  },

  /**
   * 输入框内容变化
   */
  onInputChange(event) {
    this.setData({
      inputValue: event.detail.value
    });
  },

  /**
   * 发送消息
   */
  sendMessage() {
    const message = this.data.inputValue.trim();
    if (!message || this.data.isSending) {
      return;
    }

    // 添加用户消息到列表
    const userMessage = {
      id: Date.now(),
      type: 'user',
      content: message,
      time: new Date().toLocaleTimeString()
    };

    this.setData({
      messageList: [...this.data.messageList, userMessage],
      inputValue: '',
      isSending: true,
      isWaitingReply: true,
      scrollToBottom: true
    });

    // 调用AI接口
    this.callAIAPI(message);
  },

  /**
   * 调用AI API
   */
  async callAIAPI(message) {
    try {
      const requestData = {
        message: message,
        chatType: this.data.functionType || 'general',
        modelType: this.data.currentModel,
        conversationId: this.data.sessionId
      };

      console.log('发送AI请求:', requestData);

      const response = await api.chat(requestData);
      
      if (response.success) {
        // 添加AI回复到消息列表
        const aiMessage = {
          id: Date.now() + 1,
          type: 'ai',
          content: response.data && (response.data.reply || response.data.response || ''),
          model: response.data && response.data.modelType,
          time: new Date().toLocaleTimeString()
        };

        this.setData({
          messageList: [...this.data.messageList, aiMessage],
          scrollToBottom: true
        });

        // 保存聊天记录到本地
        this.saveChatToLocal();
      } else {
        // 显示错误消息
        this.showErrorMessage(response.message || '请求失败，请稍后重试');
      }
    } catch (error) {
      console.error('AI请求失败:', error);
      this.showErrorMessage('网络错误，请检查网络连接');
    } finally {
      this.setData({
        isSending: false,
        isWaitingReply: false
      });
    }
  },

  /**
   * 显示错误消息
   */
  showErrorMessage(message) {
    const errorMessage = {
      id: Date.now() + 1,
      type: 'error',
      content: message,
      time: new Date().toLocaleTimeString()
    };

    this.setData({
      messageList: [...this.data.messageList, errorMessage],
      scrollToBottom: true
    });
  },

  /**
   * 保存聊天记录到本地
   */
  saveChatToLocal() {
    const chatData = {
      sessionId: this.data.sessionId,
      title: this.data.messageList[0]?.content.substring(0, 20) + '...' || '新对话',
      messages: this.data.messageList,
      model: this.data.currentModel,
      functionType: this.data.functionType,
      updateTime: new Date().getTime()
    };

    // 获取现有聊天记录
    const chatHistory = wx.getStorageSync('chatHistory') || [];
    
    // 查找是否已存在该会话
    const existingIndex = chatHistory.findIndex(chat => chat.sessionId === this.data.sessionId);
    
    if (existingIndex >= 0) {
      // 更新现有会话
      chatHistory[existingIndex] = chatData;
    } else {
      // 添加新会话
      chatHistory.unshift(chatData);
    }

    // 限制保存的会话数量（最多100个）
    if (chatHistory.length > 100) {
      chatHistory.splice(100);
    }

    wx.setStorageSync('chatHistory', chatHistory);
  },

  /**
   * 加载聊天历史记录
   */
  loadChatHistory(sessionId) {
    const chatHistory = wx.getStorageSync('chatHistory') || [];
    const chatData = chatHistory.find(chat => chat.sessionId === sessionId);
    
    if (chatData) {
      this.setData({
        messageList: chatData.messages,
        currentModel: chatData.model,
        functionType: chatData.functionType,
        scrollToBottom: true
      });
    }
  },

  /**
   * 滚动到底部
   */
  scrollToBottom() {
    if (this.data.scrollToBottom) {
      setTimeout(() => {
        wx.pageScrollTo({
          scrollTop: 999999,
          duration: 300
        });
        this.setData({
          scrollToBottom: false
        });
      }, 100);
    }
  },

  /**
   * 复制消息内容
   */
  copyMessage(event) {
    const content = event.currentTarget.dataset.content;
    wx.setClipboardData({
      data: content,
      success: () => {
        wx.showToast({
          title: '已复制',
          icon: 'success'
        });
      }
    });
  },

  /**
   * 重新发送消息
   */
  resendMessage(event) {
    const content = event.currentTarget.dataset.content;
    this.setData({
      inputValue: content
    });
  },

  /**
   * 重新生成AI响应
   */
  regenerateResponse(event) {
    const index = event.currentTarget.dataset.index;
    const messageList = this.data.messageList;
    
    // 找到对应的用户消息
    let userMessage = '';
    for (let i = index - 1; i >= 0; i--) {
      if (messageList[i].type === 'user') {
        userMessage = messageList[i].content;
        break;
      }
    }
    
    if (userMessage) {
      // 移除当前AI消息
      messageList.splice(index, 1);
      this.setData({
        messageList: messageList,
        isWaitingReply: true
      });
      
      // 重新调用AI接口
      this.callAIAPI(userMessage);
    }
  },

  /**
   * 清空当前对话
   */
  clearCurrentChat() {
    wx.showModal({
      title: '确认清空',
      content: '确定要清空当前对话吗？',
      success: (res) => {
        if (res.confirm) {
          this.setData({
            messageList: []
          });
          wx.showToast({
            title: '已清空',
            icon: 'success'
          });
        }
      }
    });
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    // 可以在这里刷新对话或重新加载
    wx.stopPullDownRefresh();
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {
    // 可以在这里加载更多历史消息
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {
    return {
      title: 'AI伙伴 - 智能对话助手',
      path: '/pages/talk/talk'
    };
  }
});
